// 监听页面变化，检测指定的XPath元素
(function () {
  'use strict';

  // 添加防重复执行标志
  let isExecuted = false;

  // 添加防重复保存标志
  let isSaving = false;
  let pendingContent = [];
  let hasGeneratedFile = false; // 添加全局文件生成标志
  let fileGenerationTimer = null; // 添加文件生成定时器

  // 检查XPath是否匹配的函数
  async function checkXPath() {
    if (isExecuted) {
      return true;
    }

    try {

      const result = await getElement('chat.content')
      // console.log(result, 'chat.content');

      if (result && result.snapshotLength > 0) {
        console.log('找到匹配的XPath元素，执行业务代码');

        isExecuted = true;

        for (let i = 0; i < result.snapshotLength; i++) {
          const targetElement = result.snapshotItem(i);
          console.log(`开始监听目标元素 ${i + 1}:`, targetElement);

          await checkAndLogAutoElements(targetElement);

          // 监听子元素变化
          const childObserver = new MutationObserver(async function (mutations) {
            for (const mutation of mutations) {
              if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
                // 当有新子节点添加时，检查是否有新的 //div[@dir="auto"] 元素
                for (const node of mutation.addedNodes) {
                  if (node.nodeType === Node.ELEMENT_NODE) {
                    // 使用统一的函数检查新元素，避免重复输出
                    await checkAndLogNewAutoElements(node, targetElement);
                  }
                }
              }
            }
          });

          // 开始监听子元素变化
          childObserver.observe(targetElement, {
            childList: true,
            subtree: true
          });

          // 将observer保存到元素上，以便后续清理
          targetElement._childObserver = childObserver;
        }

        return true;
      }

      return false;
    } catch (error) {
      console.error('XPath检查出错:', error);
      return false;
    }
  }

  // 检查并输出已有的 auto 元素
  async function checkAndLogAutoElements(parentElement) {
    try {
      let xpath = await getXpath('chat.item')
      if (!xpath) {
        console.error('无法获取chat.item的XPath');
        return [];
      }
      const autoElements = parentElement.querySelectorAll(xpath);
      console.log(`在目标元素下找到 ${autoElements.length} 个已有的 auto 元素`);

      // 收集所有内容用于保存到文件
      const contentToSave = [];

      autoElements.forEach(async function (autoEl, index) {
        console.log(`已有的 auto 元素 ${index + 1}:`, autoEl);
        console.log(`内容:`, autoEl.textContent);
        const name = await getAutoRole(parentElement)
        console.log(`角色:`, name);

        // 为已有元素添加标记，避免重复输出
        autoEl.setAttribute('data-auto-processed', 'true');

        // 收集内容
        contentToSave.push({
          content: autoEl.textContent?.trim() || '',
          name: name
        });
      });

      // 保存内容到文件
      if (contentToSave.length > 0) {
        saveContentToFile(contentToSave, 'existing_elements');
      }

      return contentToSave;
    } catch (error) {
      console.error('检查已有 auto 元素时出错:', error);
      return [];
    }
  }

  async function getAutoRole(parentElement) {
    try {
      let xpath = await getXpath('chat.other')
      if (!xpath) {
        console.error('无法获取chat.other的XPath');
        return [];
      }
      const autoRole = parentElement.querySelectorAll(xpath);
      if (autoRole.length > 0) {
        // 对方发出的消息
        let nameElem = await getElementNodeValue('chat.otherName')
        if (nameElem) {
          return nameElem.textContent?.trim() || ''
        }
        return ''
      } else {
        // 自己发出的消息
        let nameElem = await getElementNodeValue('chat.myName')
        if (nameElem) {
          return nameElem.textContent?.trim() || ''
        }
        return ''
      }


    } catch (error) {
      console.error('获取auto角色时出错:', error);
      return [];
    }

  }

  // 检查并输出新的 auto 元素（避免重复）
  async function checkAndLogNewAutoElements(node, parentElement) {
    try {
      // 检查节点是否有效
      if (!node || !node.nodeType || node.nodeType !== Node.ELEMENT_NODE) {
        return;
      }

      // 收集新发现的内容
      const newContentToSave = [];
      let xpath = await getXpath('chat.item')
      if (!xpath) {
        console.error('无法获取chat.item的XPath');
        return [];
      }

      // 检查新添加的节点本身
      if (node.matches && node.matches(xpath)) {
        // 检查是否已经处理过
        if (!node.hasAttribute('data-auto-processed')) {
          console.log('发现新的元素:', node);
          node.setAttribute('data-auto-processed', 'true');

          // 收集新内容
          newContentToSave.push({
            content: node.textContent?.trim() || ''
          });
        } else {
          console.log('跳过已处理的元素:', node);
        }
      }

      // 检查新添加节点下的所有 auto 元素
      const autoElements = node.querySelectorAll(xpath);
      if (autoElements.length > 0) {
        console.log(`在节点下找到 ${autoElements.length} 个 auto 子元素`);
      }

      autoElements.forEach(async function (autoEl, index) {
        // 检查是否已经处理过
        if (!autoEl.hasAttribute('data-auto-processed')) {
          console.log(`发现新的子元素 ${index + 1}:`, autoEl);
          autoEl.setAttribute('data-auto-processed', 'true');
          const name = await getAutoRole(parentElement)
          console.log(`角色:`, name);

          // 收集新内容
          newContentToSave.push({
            content: autoEl.textContent?.trim() || '',
            name: name
          });
        } else {
          console.log(`跳过已处理的子元素 ${index + 1}:`, autoEl);
        }
      });

      // 保存新发现的内容到文件（只在有内容时保存）
      if (newContentToSave.length > 0) {
        // 立即添加到保存队列，避免频繁生成文件
        saveContentToFile(newContentToSave, 'new_elements');
      }

      return newContentToSave;
    } catch (error) {
      console.error('检查新的 auto 元素时出错:', error);
      return [];
    }
  }

  // 保存内容到文件
  function saveContentToFile(contentArray, source) {
    try {
      // 如果正在保存，将内容添加到待处理队列
      if (isSaving) {
        pendingContent = pendingContent.concat(contentArray);
        console.log('内容已添加到待处理队列，当前队列长度:', pendingContent.length);
        return;
      }

      // 设置保存标志
      isSaving = true;

      // 合并待处理内容和当前内容
      const allNewContent = pendingContent.concat(contentArray);
      pendingContent = []; // 清空待处理队列

      // 获取已存储的内容
      getStoredContent().then(existingContent => {
        // 合并新内容和已有内容
        const allContent = existingContent.concat(allNewContent);

        // 更新存储的内容
        updateStoredContent(allContent);

        // 重置保存标志
        isSaving = false;

        console.log(`内容已保存到存储，当前总计 ${allContent.length} 条记录`);

        // 延迟生成文件，让内容能够持续收集
        scheduleFileGeneration();
      });
    } catch (error) {
      console.error('保存文件时出错:', error);
      isSaving = false;
    }
  }

  // 延迟文件生成函数
  function scheduleFileGeneration() {
    // 清除之前的定时器
    if (fileGenerationTimer) {
      clearTimeout(fileGenerationTimer);
    }

    // 如果已经生成过文件，则不再生成
    if (hasGeneratedFile) {
      return;
    }

    // 设置延迟生成文件（3秒后生成，给内容收集留出时间）
    fileGenerationTimer = setTimeout(() => {
      generateFinalFile();
    }, 3000);

    console.log('已安排文件生成，3秒后生成最终文件');
  }

  // 生成最终文件
  function generateFinalFile() {
    if (hasGeneratedFile) {
      return;
    }

    console.log('开始生成最终文件...');

    getStoredContent().then(allContent => {
      if (allContent.length === 0) {
        console.log('没有内容可保存');
        return;
      }

      // 格式化所有内容为单行格式（去重）
      const formattedContent = formatContentForSingleLine(allContent);

      // 保存合并后的内容
      saveMergedContent(formattedContent, allContent);

      // 设置全局文件生成标志
      hasGeneratedFile = true;

      console.log('最终文件生成完成，后续内容将不再生成新文件');
    });
  }

  // 获取已存储的内容
  function getStoredContent() {
    return new Promise((resolve) => {
      if (chrome && chrome.storage && chrome.storage.local) {
        chrome.storage.local.get(['chatContent'], function (result) {
          resolve(result.chatContent || []);
        });
      } else {
        // 降级到localStorage
        try {
          const stored = localStorage.getItem('chatContent');
          resolve(stored ? JSON.parse(stored) : []);
        } catch (error) {
          console.error('获取存储内容失败:', error);
          resolve([]);
        }
      }
    });
  }

  // 保存合并后的内容
  function saveMergedContent(formattedContent, allContent) {
    try {
      // 创建Blob对象
      const blob = new Blob([formattedContent], { type: 'text/plain;charset=utf-8' });

      // 使用Chrome下载API保存文件
      if (chrome && chrome.downloads) {
        // 使用时间戳确保文件名唯一
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
        const filename = `chat_${timestamp}.txt`;

        chrome.downloads.download({
          url: URL.createObjectURL(blob),
          filename: filename,
          saveAs: false // 自动保存到下载目录
        }, function (downloadId) {
          if (chrome.runtime.lastError) {
            console.error('下载失败:', chrome.runtime.lastError);
            // 降级到手动下载
            fallbackDownload(blob, filename);
          } else {
            console.log(`内容已保存到文件: ${filename}，共 ${allContent.length} 条记录，去重后 ${formattedContent.split('\n').length} 条内容`);
            // 更新存储的内容
            updateStoredContent(allContent);
          }
        });
      } else {
        // 降级到手动下载
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
        const filename = `chat_${timestamp}.txt`;
        fallbackDownload(blob, filename);
        // 更新存储的内容
        updateStoredContent(allContent);
      }
    } catch (error) {
      console.error('保存合并内容时出错:', error);
    }
  }

  // 更新存储的内容
  function updateStoredContent(allContent) {
    try {
      if (chrome && chrome.storage && chrome.storage.local) {
        chrome.storage.local.set({ chatContent: allContent }, function () {
          if (chrome.runtime.lastError) {
            console.error('更新存储失败:', chrome.runtime.lastError);
          } else {
            console.log('存储内容已更新，当前记录数:', allContent.length);
          }
        });
      } else {
        // 降级到localStorage
        try {
          localStorage.setItem('chatContent', JSON.stringify(allContent));
          console.log('localStorage内容已更新，当前记录数:', allContent.length);
        } catch (error) {
          console.error('更新localStorage失败:', error);
        }
      }
    } catch (error) {
      console.error('更新存储内容时出错:', error);
    }
  }

  // 格式化内容为单行格式（追加模式）
  function formatContentForSingleLine(contentArray) {
    // 去重，只保留唯一的内容
    const uniqueContent = [];
    const seenContent = new Set();

    contentArray.forEach(item => {
      if (item.content && !seenContent.has(item.content)) {
        uniqueContent.push(item.content);
        seenContent.add(item.content);
      }
    });

    // 每条内容一行
    return uniqueContent.join('\n');
  }

  // 降级下载方法（手动下载）
  function fallbackDownload(blob, filename) {
    try {
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = filename;
      a.style.display = 'none';
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);

      console.log(`内容已通过手动下载保存到: ${filename}`);
    } catch (error) {
      console.error('手动下载失败:', error);
    }
  }

  // 主要的监听函数
  async function startMonitoring() {
    console.log('开始监听页面变化...');

    // 初始检查
    if (await checkXPath()) {
      return;
    }

    // 使用MutationObserver监听DOM变化
    const observer = new MutationObserver(async function (mutations) {
      // 如果已经执行过，则不再执行
      if (isExecuted) {
        return;
      }

      // 检查是否有相关的变化
      for (const mutation of mutations) {
        if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
          // 当有新节点添加时，检查XPath
          if (await checkXPath()) {
            observer.disconnect(); // 找到后停止监听
            return;
          }
        }
      }
    });

    // 开始监听
    observer.observe(document.body, {
      childList: true,
      subtree: true
    });

    // 设置超时检查（每2秒检查一次）
    const intervalCheck = setInterval(async function () {
      // 如果已经执行过，则停止检查
      if (isExecuted) {
        clearInterval(intervalCheck);
        return;
      }

      if (await checkXPath()) {
        clearInterval(intervalCheck);
        observer.disconnect();
      }
    }, 2000);

    // 页面卸载时清理
    window.addEventListener('beforeunload', async function () {
      observer.disconnect();
      clearInterval(intervalCheck);

      // 清理所有子元素监听器 - 使用XPath查找，因为CSS选择器不支持contains语法
      try {
        const result = await getElement('chat.content')
        if (result) {
          for (let i = 0; i < result.snapshotLength; i++) {
            const element = result.snapshotItem(i);
            if (element._childObserver) {
              element._childObserver.disconnect();
              delete element._childObserver;
            }
          }
        }
      } catch (error) {
        console.error('清理子元素监听器时出错:', error);
      }
    });
  }

  // 等待页面加载完成后开始监听
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', startMonitoring);
  } else {
    startMonitoring();
  }

  // 为了兼容性，也监听window的load事件
  window.addEventListener('load', function () {
    // if (!businessLogicManager.isExecuted) {
    //   startMonitoring();
    // }
  });

  // 暴露重置功能到全局（用于调试）
  window.resetExtension = function () {
    isExecuted = false;
    hasGeneratedFile = false; // 重置文件生成标志

    // 清除文件生成定时器
    if (fileGenerationTimer) {
      clearTimeout(fileGenerationTimer);
      fileGenerationTimer = null;
    }

    console.log('扩展状态已重置，可以重新执行和生成文件');
  };

  // 暴露状态查询功能到全局（用于调试）
  window.getExtensionStatus = function () {
    return {
      isExecuted: isExecuted,
      hasGeneratedFile: hasGeneratedFile,
      hasTimer: fileGenerationTimer !== null,
      message: isExecuted ? '已执行' : '未执行',
      fileStatus: hasGeneratedFile ? '已生成文件' : (fileGenerationTimer ? '等待生成文件' : '未安排生成文件')
    };
  };

  // 暴露查看存储内容功能到全局（用于调试）
  window.viewStoredContent = function () {
    getStoredContent().then(content => {
      console.log('当前存储的内容:', content);
      console.log('总记录数:', content.length);

      if (content.length > 0) {
        console.log('最新5条记录:');
        content.slice(-5).forEach((item, index) => {
          console.log(`${content.length - 4 + index}: ${item.timestamp} | ${item.type} | ${item.content}`);
        });
      }
    });
  };

  // 暴露手动导出文件功能到全局（用于调试）
  window.exportChatFile = function () {
    getStoredContent().then(content => {
      if (content.length === 0) {
        console.log('没有存储的内容可导出');
        return;
      }

      const formattedContent = formatContentForSingleLine(content);
      const blob = new Blob([formattedContent], { type: 'text/plain;charset=utf-8' });

      // 使用手动下载
      fallbackDownload(blob, 'chat_export.txt');
      console.log(`手动导出完成，共 ${content.length} 条记录`);
    });
  };

  // 暴露立即生成文件功能到全局（用于调试）
  window.generateFileNow = function () {
    if (hasGeneratedFile) {
      console.log('文件已生成，无法重复生成');
      return;
    }

    // 清除定时器
    if (fileGenerationTimer) {
      clearTimeout(fileGenerationTimer);
      fileGenerationTimer = null;
    }

    // 立即生成文件
    generateFinalFile();
  };

  // 暴露清空存储内容功能到全局（用于调试）
  window.clearStoredContent = function () {
    try {
      if (chrome && chrome.storage && chrome.storage.local) {
        chrome.storage.local.remove(['chatContent'], function () {
          console.log('存储内容已清空');
        });
      } else {
        localStorage.removeItem('chatContent');
        console.log('localStorage内容已清空');
      }
    } catch (error) {
      console.error('清空存储内容失败:', error);
    }
  };



  // 添加消息监听器，处理来自弹窗的消息
  if (chrome && chrome.runtime && chrome.runtime.onMessage) {
    chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
      console.log('收到来自弹窗的消息:', request);

      try {
        switch (request.action) {
          case 'ping':
            // 响应 ping 消息，确认内容脚本已加载
            sendResponse({ success: true, message: '内容脚本已加载' });
            break;

          case 'resetExtension':
            // 重置扩展状态
            window.resetExtension();
            sendResponse({ success: true, message: '扩展已重置' });
            break;

          case 'getExtensionStatus':
            // 获取扩展状态
            const status = window.getExtensionStatus();
            sendResponse(status);
            break;

          case 'viewStoredContent':
            // 查看存储的内容
            getStoredContent().then(content => {
              sendResponse({ content: content });
            });
            return true; // 保持消息通道开放，等待异步响应

          case 'generateFileNow':
            // 立即生成文件
            if (typeof window.generateFileNow === 'function') {
              window.generateFileNow();
              sendResponse({ success: true, message: '文件生成已启动' });
            } else {
              sendResponse({ success: false, message: '文件生成功能不可用' });
            }
            break;

          case 'clearStoredContent':
            // 清空存储内容
            if (typeof window.clearStoredContent === 'function') {
              window.clearStoredContent();
              sendResponse({ success: true, message: '存储内容已清空' });
            } else {
              sendResponse({ success: false, message: '清空功能不可用' });
            }
            break;



          case 'fillInputField':
            try {
              console.log('开始执行 fillInputField 操作');

              // 检查 autoSearchPerson 函数是否存在
              if (typeof autoSearchPerson === 'function') {
                console.log('调用 autoSearchPerson 函数');
                autoSearchPerson();
                sendResponse({
                  success: true,
                  message: 'autoSearchPerson 函数已执行'
                });
              } else {
                console.error('autoSearchPerson 函数不存在');
                sendResponse({
                  success: false,
                  message: 'autoSearchPerson 函数不存在，请检查导入'
                });
              }
            } catch (error) {
              console.error('执行 fillInputField 时出错:', error);
              sendResponse({
                success: false,
                message: '执行失败: ' + error.message
              });
            }
            break;

          default:
            sendResponse({ success: false, message: '未知操作' });
        }
      } catch (error) {
        console.error('处理消息时出错:', error);
        sendResponse({ success: false, message: '操作失败: ' + error.message });
      }
    });
  }

})();

